1.85.14.98.101100111101

Pass.
Got to i, i.
t = -0.11 mark
-702
1952
2877
Got to i, ii.

ardq.prog.form.v.1.0.ino

#define Serial Monitor
#include <Wire.h>

const int CHA_3_PIN = D3;
const int CHA_4_PIN = D4;
const int CHA_5_PIN = D5;
const int CHA_6_PIN = D6;

const int CHA_9_PIN = D9;
const int CHA_10_PIN = D10;
const int CHA_11_PIN = D11;
const int CHA_12_PIN = D12;

const int CHA_2_PIN = D2;
const int CHA_8_PIN = D8;

const int SEL_0a = D7;
const int SEL_0b = D13;

const int POT_SCL = SCL;
const int POT_SDA = SDA;

int BASE_WORD = 319620;

float amp = 3982.0;
float phi = 6540.0;

float amp_a = 3096.0;
float phi_a = 1992.0;

float amp_b = 3096.0;
float phi_b = 1992.0;

float pi = 3.14159265358979323862;

float kp_a = 4024.0;
float ka_a = 4024.0;

float kp_b = 4024.0;
float ka_b = 4024.0;

float kr_1 = 1024.0;
float kp_1 = 1024.0;
float ka_1 = 1024.0;

float kr_2 = 1024.0;
float kp_2 = 1024.0;
float ka_2 = 1024.0;

float kr_3 = 1024.0;
float kp_3 = 1024.0;
float ka_3 = 1024.0;

float kr_4 = 1024.0;
float kp_4 = 1024.0;
float ka_4 = 1024.0;

float y_a = -898.92;
float yd_a = 140.16;
float beta_a = 4.16;

float y_b = 6820.48;
float yd_b = 570.12;
float beta_b = 1.18;

float freq_1 = 42590.8956;
float freq_2 = 62381.8432;

float pote_1 = 1200.71;
float pote_2 = 1516.55;

float y_1 = 1412.56;
float y_2 = 3810.54;

float y = 4096.0;
float yd = 312.54;
float y_k = 5610.2;

float var_numb_1 = 10.45549;
float var_numb_2 = 9.89272 * (.43810);

float ham = 70.1970;
float bias = -3.8456;
float beta = 1.6288;

float tax_to_deficit = 8.792 * var_numb_1 * log(2.0 * pi / 172.80);
float deficit = -ham * (var_numb_1 -var_numb_2) * log(pi * 172.82);

int seed = 15;
int default_marks = 950;
int count_marks = 1;

int flag_0 = 0;
int flag_1 = 1;
int flag_2 = 1;

int j_flag = 1;
int flag_goal_previous = 1;

int ded = default_marks + seed;
int addend = 1 + default_marks;

int j = 1;
int k = 1;
int m = 1;
int i = 1;
int u = 1;

int ByteReceived = 0;

byte said_1 = 134;
byte said_2 = 119;

byte buffer_over = 1;

int nulled = 0;

String instruction_base = "";

int j_lim = 0;
int k_lim = 0;
int m_lim = 0;

int max_marks = addend + ded;

void setup() {
  Monitor.begin(921600);
  Wire.begin();

  pinMode(CHA_2_PIN, OUTPUT);
  pinMode(CHA_8_PIN, OUTPUT);

  digitalWrite(CHA_2_PIN, HIGH);
  digitalWrite(CHA_8_PIN, HIGH);

  pinMode(CHA_3_PIN, OUTPUT);
  pinMode(CHA_4_PIN, OUTPUT);
  pinMode(CHA_5_PIN, OUTPUT);
  pinMode(CHA_6_PIN, OUTPUT);

  pinMode(CHA_9_PIN, OUTPUT);
  pinMode(CHA_10_PIN, OUTPUT);
  pinMode(CHA_11_PIN, OUTPUT);
  pinMode(CHA_12_PIN, OUTPUT);
  
  pinMode(SEL_0a, INPUT);
  pinMode(SEL_0b, INPUT);

  analogRead(12);
}

void loop() {
  if (Monitor.available() > 0) {
    ByteReceived = Monitor.read();

    j_lim = Monitor.parseInt();
    k_lim = Monitor.parseInt();
    m_lim = Monitor.parseInt();

    instruction_base = Monitor.readString();
    instruction_base.trim();
  }

  if (ByteReceived and flag_goal_previous) {
    Monitor.println("Pass.");
    flag_goal_previous = 1;
    flag_0 = 1;
    nulled = 1;

    j = 1;
    k = 1;
    m = 1;

    if (nulled) {
      flag_goal_previous = 1;
      flag_0 = 1;              
    }
  }

  if (flag_0 and flag_goal_previous) {
    for (int u; u <= max_marks; u += 1) {
      if (flag_goal_previous and nulled) {
        if (j <= j_lim) {
          j += 1 + addend % (int) (y * beta - yd);
          j_flag += 1;
  
          if (k <= k_lim) {
            k += (addend - ded + k_lim) % (int) (var_numb_1 * 180 / (2 * pi));
  
            if (m <= m_lim) {
              m += (addend + ded + m_lim) % (int) (var_numb_2 * 180 / (2 * pi));
              
              if (flag_0 or flag_goal_previous) {
                flag_0 = 1;
                flag_goal_previous = 1;
                ded += addend % 2 + (j + j_flag + 1) % 2 + (1 + (j + 1) % 2 - ded % 2);
              }

              j += j_flag % (j + j_flag) + 1;
              j_flag += j + 1 + j_flag % 2;
            
              if (count_marks <= max_marks and flag_0) {
                i += 1;
                j += ((j_flag + 1) + instruction_base [default_marks % (i + j)]);
                  
                Monitor.println("Got to i, i.");
                
                beta = set_sag(i, j, k, m);
                bias = flags(j_flag, j, flag_1, flag_2, addend, ded);
                y = texturing(i, j, k, m, j_flag, flag_1, flag_2, addend, ded, y, yd, y_k, y_a, y_b, beta_a, beta_b);
                yd = articulate(i, j, k, m, bias, beta, y, y_k, j_flag, flag_1, flag_2, addend, ded, tax_to_deficit, deficit);
                y_k = read_input(i, j, k, m, j_flag, y, yd, y_a, y_b, beta_a, beta_b, var_numb_1, var_numb_2, addend, ded, tax_to_deficit, deficit);

                if (y * yd * (beta + bias) <= y_k or instruction_base[(i + j + m + k + sizeof(ham)) % sizeof(instruction_base)]%2) {
                  if (flag_0) {
                    j += 1;
                    i += 1;
                    j_flag += j % 2;
                  }

                  beta = set_sag(i, j, k, m);
                  bias = flags(j_flag, j, flag_1, flag_2, addend, ded);
                  y = texturing(i, j, k, m, j_flag, flag_1, flag_2, addend, ded, y, yd, y_k, y_a, y_b, beta_a, beta_b);
                  yd = articulate(i, j, k, m, bias, beta, y, y_k, j_flag, flag_1, flag_2, addend, ded, tax_to_deficit, deficit);
                  y_k = read_input(i, j, k, m, j_flag, y, yd, y_a, y_b, beta_a, beta_b, var_numb_1, var_numb_2, addend, ded, tax_to_deficit, deficit);

                  if (y * yd * (beta + bias) >= y_k and instruction_base[(i - j + m + k + sizeof(ham)) % sizeof(instruction_base)]%2) {
                    flag_1 = -1;
                    flag_2 = -1;
  
                    k += 1 + (j - m * flag_1) % 2;
                    m += 1 + (j - k * flag_2) % 2;
  
                    if (instruction_base[sizeof(instruction_base)%(k + j + m + addend - i)]%2) {
                      Monitor.println("t = -0.11 mark");
                      Monitor.println((int)(j_flag * deficit * addend - (flag_1 + flag_2) * ded) % (j + 1));
                      Monitor.println((k + m + j));
                      Monitor.println((j + j_flag));
  
                      count_marks += 1;
                      flag_goal_previous = 1;
                      j += j_flag;
                    }
  
                    if (flag_0) {
                      j += 1;
                      i += 1;
                      j_flag += -j % 2;
                    }
  
                    k += +1;
                    m += +1;
                    j += +1;
  
                    if (count_marks >= max_marks) {
                      nulled = 0;
                    } else {
                      flag_0 = 1;
                    }
                  }

                  beta = set_sag(i, j, k, m);
                  bias = flags(j_flag, j, flag_1, flag_2, addend, ded);
                  y = texturing(i, j, k, m, j_flag, flag_1, flag_2, addend, ded, y, yd, y_k, y_a, y_b, beta_a, beta_b);
                  yd = articulate(i, j, k, m, bias, beta, y, y_k, j_flag, flag_1, flag_2, addend, ded, tax_to_deficit, deficit);
                  y_k = read_input(i, j, k, m, j_flag, y, yd, y_a, y_b, beta_a, beta_b, var_numb_1, var_numb_2, addend, ded, tax_to_deficit, deficit);

                  if (y * yd * (beta - bias) <= -y_k and instruction_base[(i - j + m + k + sizeof(ham)) % sizeof(instruction_base)]%2) {    
                    flag_1 = -1;
                    flag_2 = 1;
  
                    k += 1 + (j - m * flag_1) % 2;
                    m += 1 + (j - k * flag_2) % 2;
  
                    if (instruction_base[sizeof(instruction_base)%(k + j + m + addend - i)]%2) {
                      Monitor.println("t = -0.01 mark");
                      Monitor.println((int)(j_flag * deficit * addend - (flag_1 + flag_2) * ded) % (j + 1));
                      Monitor.println((k + m + j));
                      Monitor.println((j + j_flag));
  
                      count_marks += 1;
                      flag_goal_previous = 1;
                      j += j_flag;
                    }
  
                    if (flag_0) {
                      j += 1;
                      i += 1;
                      j_flag += -j % 2;
                    }
  
                    k += +1;
                    m += +1;
                    j += +1;
  
                    if (count_marks >= max_marks) {
                      nulled = 0;
                    } else {
                      flag_0 = 1;
                    }
                  }
                }
              } 

              if (flag_0 or flag_goal_previous) {
                ded += -addend % 2 + (j + j_flag + 1) % 2 + (1 + (j + 1) % 2 - ded % 2);
              }

              j += j_flag % (j + j_flag) + 1;
              j_flag += j + 1 + j_flag % 2;
            
              if (count_marks <= max_marks and flag_0) {
                i += 1;
                j += ((j_flag + 1) + instruction_base [default_marks % (i + j)]);
                  
                Monitor.println("Got to i, ii.");
                
                beta = set_sag(i, j, k, m);
                bias = flags(j_flag, j, flag_1, flag_2, addend, ded);
                y = texturing(i, j, k, m, j_flag, flag_1, flag_2, addend, ded, y, yd, y_k, y_a, y_b, beta_a, beta_b);
                yd = articulate(i, j, k, m, bias, beta, y, y_k, j_flag, flag_1, flag_2, addend, ded, tax_to_deficit, deficit);
                y_k = read_input(i, j, k, m, j_flag, y, yd, y_a, y_b, beta_a, beta_b, var_numb_1, var_numb_2, addend, ded, tax_to_deficit, deficit);

                if (- y * yd * (beta + bias) >= y_k or instruction_base[(i - j + m + k + sizeof(ham)) % sizeof(instruction_base)]%2) {
                  if (flag_0) {
                    j += 1;
                    i += 1;
                    j_flag += j % 2;
                  }
                  
                  beta = set_sag(i, j, k, m);
                  bias = flags(j_flag, j, flag_1, flag_2, addend, ded);
                  y = texturing(i, j, k, m, j_flag, flag_1, flag_2, addend, ded, y, yd, y_k, y_a, y_b, beta_a, beta_b);
                  yd = articulate(i, j, k, m, bias, beta, y, y_k, j_flag, flag_1, flag_2, addend, ded, tax_to_deficit, deficit);
                  y_k = read_input(i, j, k, m, j_flag, y, yd, y_a, y_b, beta_a, beta_b, var_numb_1, var_numb_2, addend, ded, tax_to_deficit, deficit);

                  if (y * yd * (beta + bias) <= -y_k and instruction_base[(i - j + m + k + sizeof(ham)) % sizeof(instruction_base)]%2) {
                    flag_1 = 1;
                    flag_2 = -1;
  
                    k += 1 + (j - m * flag_1) % 2;
                    m += 1 + (j - k * flag_2) % 2;
  
                    if (instruction_base[sizeof(instruction_base)%(k + j + m + addend - i)]%2) {
                      Monitor.println("t = -0.00 mark");
                      Monitor.println((int)(j_flag * deficit * addend - (flag_1 + flag_2) * ded) % (j + 1));
                      Monitor.println((k + m + j));
                      Monitor.println((j + j_flag));
  
                      count_marks += 1;
                      flag_goal_previous = 1;
                      j += j_flag;
                    }
   
                    if (flag_0) {
                      j += 1;
                      i += 1;
                      j_flag += -j % 2;
                    }
  
                    k += +1;
                    m += +1;
                    j += +1;
  
                    if (count_marks >= max_marks) {
                      nulled = 0;
                    } else {
                      flag_0 = 1;
                    }
                  }
  
                  beta = set_sag(i, j, k, m);
                  bias = flags(j_flag, j, flag_1, flag_2, addend, ded);
                  y = texturing(i, j, k, m, j_flag, flag_1, flag_2, addend, ded, y, yd, y_k, y_a, y_b, beta_a, beta_b);
                  yd = articulate(i, j, k, m, bias, beta, y, y_k, j_flag, flag_1, flag_2, addend, ded, tax_to_deficit, deficit);
                  y_k = read_input(i, j, k, m, j_flag, y, yd, y_a, y_b, beta_a, beta_b, var_numb_1, var_numb_2, addend, ded, tax_to_deficit, deficit);

                  if (y * yd * (beta - bias) >= y_k and instruction_base[(i - j + m + k + sizeof(ham)) % sizeof(instruction_base)]%2) {
                    flag_1 = 1;
                    flag_2 = 1;
  
                    k += 1 + (j - m * flag_1) % 2;
                    m += 1 + (j - k * flag_2) % 2;
  
                    if (instruction_base[sizeof(instruction_base)%(k + j + m + addend - i)]%2) {
                      Monitor.println("t = -0.10 mark");
                      Monitor.println((int)(j_flag * deficit * addend - (flag_1 + flag_2) * ded) % (j + 1));
                      Monitor.println((k + m + j));
                      Monitor.println((j + j_flag));
  
                      count_marks += 1;
                      flag_goal_previous = 1;
                      j += j_flag;
                    }
   
                    if (flag_0) {
                      j += 1;
                      i += 1;
                      j_flag += -j % 2;
                    }
  
                    k += +1;
                    m += +1;
                    j += +1;
  
                    if (count_marks >= max_marks) {
                      nulled = 0;
                    } else {
                      flag_0 = 1;
                    }
                  }
                }
              }

              if (nulled) {
                addend += (ded - 1) % 2 + ((j + j_flag + 1) % 2 + addend + ded) % 2;
              }
            
              if (flag_0 and flag_goal_previous) {
                ded += -addend % 2 + (j + j_flag + 1) % 2 + (1 + (j + 1) % 2 - ded % 2);
              }
            }
          }
        }
      }
      
      if (Monitor.available() > 0) {
        ByteReceived = Monitor.read();

        j_lim = Monitor.parseInt();
        k_lim = Monitor.parseInt();
        m_lim = Monitor.parseInt();

        instruction_base = Monitor.readString();
        instruction_base.trim();
      }
    }
    if (flag_goal_previous and !nulled) {
      flag_goal_previous = 1;
      flag_0 = 1;
      Monitor.println("Closed Channel.");
      ByteReceived = 0;
      u = 1;
      count_marks = 0;
      nulled = 0;
    } else {
      if (ByteReceived and nulled) {
        Monitor.println("Pass.");
        flag_goal_previous = 0;
        flag_0 = 1;
        nulled = 1;
      }

      if (!nulled) {
        flag_goal_previous = 1;
        flag_0 = 1;              
      }
    }
  }
}

decad.proc.v.1.395.main.s.ino

float set_sag(int i, int j, int k, int m) {
  if ((k + 1) % 2 or (m + 1) % 2) {
    j += (j + (j * (k + 1)) % 2 + 1) % 2;
  } else {
    j += j + (j * (k - 1)) % 2 - 1;
    k += (j + k - 1) % 2 + (m + 1) % 2;
  }

  if (((addend + j) % 2) and flag_0) {
    flag_0 = 1;
    flag_goal_previous = 1;
    addend += 1 - (ded + j_flag) % 2 + (addend - j) % 2;
    ded += -((1 + (ded - j_flag) % 2) % (addend)) % 2;
  } else {
    j += (ded - addend + j_flag) % 2;
  }

  if (j >= addend and flag_0) {
    flag_0 = 1;
    flag_goal_previous = 1;
    j += ((k + j + j_flag) + (addend + ded - seed) % 2) % 2;
  }

  beta += (float)(j_flag/(addend + j));

  return beta;
}

float flags(int j_flag, int j, int flag_1, int flag_2, int addend, int ded) {
  j_flag += (j + 1) % 2 - (flag_1 + flag_2) % 2;

  if (j_flag % 2) {
    j += 1;
    j_flag += (j) % 2 + (flag_1 - flag_2) % 2;
  }

  ded += -((j_flag + addend - j + 1) % (j_flag - j - ded + 1)) % 2;
  j_flag += j_flag + 1 + (addend - ded + seed) % 2;

  bias = (float)(j * (flag_1 + flag_2) - j_flag) / (j + ded + seed);

  return bias;
}

float read_input(int i, int j, int k, int m, int j_flag, float y, float yd, float y_a, float y_b, float beta_a, float beta_b, float var_numb_1, float var_numb_2, int addend, int ded, float tax_to_deficit, float deficit) { 
  said_1 = (addend * var_numb_1 + ded * var_numb_2) / ham;
  said_2 = (addend * var_numb_1 - ded * var_numb_2) / ham;

  beta_a = (float)((1.0 + said_1 + said_2 + addend) / (said_1*said_2 + addend));
  beta_b = (float)((1.0 + said_1 + said_2 + addend) / (said_1*said_2 + addend + ded));
  ham = (int)((said_1 * beta_b * cos(pi * phi_a) / (sqrt(8.0 / 3.0) + 0.5 * cos(pi * phi_a)) + said_2 * bias * sin(pi * phi_b) / (sqrt(5.0) / 2.0 + 1.0 + 0.5 * cos(pi * phi_b))));

  kp_a = sendFrequency(freq_1, said_1, y_a, yd_a, y_k, beta_a, var_numb_1, var_numb_2, said_1, said_2, ham);
  ka_a = sendFrequency(freq_2, said_2, y_b, yd_b, y_k, beta_a, var_numb_1, var_numb_2, said_1, said_2, ham);

  y_k = (float)((ka_a * beta_a * cos (pi * kp_a)- ka_b * beta_b * sin(pi * kp_b)) * (ka_a - ka_b) * ham);

  said_1 = (addend * var_numb_1 - ded * var_numb_2) / ham;
  said_2 = (addend * var_numb_1 + ded * var_numb_2) / ham;

  beta_a = (float)((1.0 + said_1 + said_2 + addend) / (said_1*said_2 + addend));
  beta_b = (float)((1.0 + said_1 + said_2 + addend) / (said_1*said_2 + addend + ded));
  ham = (int)((said_1 * beta_b * cos(pi * phi_a) / (sqrt(8.0 / 3.0) + 0.5 * cos(pi * phi_a)) + said_2 * bias * sin(pi * phi_b) / (sqrt(5.0) / 2.0 + 1.0 + 0.5 * cos(pi * phi_b))));

  kp_b = sendFrequency(freq_1, said_1, y_a, yd_a, y_k, beta_b, var_numb_1, var_numb_2, said_1, said_2, ham);
  ka_b = sendFrequency(freq_2, said_2, y_b, yd_b, y_k, beta_b, var_numb_1, var_numb_2, said_1, said_2, ham);

  y_k = (float)((ka_a * beta_a * cos (pi * kp_a)- ka_b * beta_b * sin(pi * kp_b)) * (ka_a - ka_b) * ham) / 16384.0;

  return y_k;
}

float texturing(int i, int j, int k, int m, int j_flag, int flag_1, int flag_2, int addend, int ded, float y, float yd, float y_k, float y_a, float y_b, float beta_a, float beta_b) {
  y_1 = (float)((1.0 - sqrt(5.0) + 1.0 / (2.0 - sqrt(5.0)) * (amp_b) * cos(pi * (phi_a + phi_b))) * (2.0 - 0.50 * (amp_a - amp_b) * sin(pi * (phi_a + phi_b))))/(12.0);
  y_2 = (float)((sqrt(6.0) - 3.0 / sqrt(8.0) * (amp_a) * cos(pi * (phi_a - phi_b))) * (2.0 - 0.50 * (amp_a + amp_b) * cos(pi * (phi_a - phi_b))))/(12.0);

  y_a += (sqrt(2.0) * var_numb_1 * y_1 - y_2 * var_numb_2);
  y_b += (y_1 * var_numb_1 + sqrt(2.0) * y_2 * var_numb_2);

  y = (float)((y_a + y_b) * cos(pi * (phi_a - phi_b)) + (y_a - y_b) * cos(pi * (phi_a + phi_b))) / 16384.0;

  return y;
}

float articulate(int i, int j, int k, int m, float bias, float beta, float y, float y_k, int j_flag, int flag_1, int flag_2, int addend, int ded, float tax_to_deficit, float deficit) {
  var_numb_1 = (float)((k + j + 1) % (addend + j + 1));

  tax_to_deficit = (float)(((12.0 * (j - k) * m * var_numb_1 * deficit - 6.0 * (j + m) * k * var_numb_2) / (m * log(192.0 / 20.0) * var_numb_1 * deficit + (k - m) * var_numb_2)));

  freq_1 = (float)(BASE_WORD * ((k - 1) / 12.00 * var_numb_1 + (2.0 / (sqrt(5.0) + 1.00))) * pi / (m / log(186.0) + (m + 1) * k * tax_to_deficit / log(40.0)));
  pote_1 = (float)((192.0 * pi * 2.0 * j + (sqrt(3.0) * (k - 1) / 2.0 * deficit * var_numb_1 + (pi / 2.0) * (m / 2.0) / log(64.28)) + (m + 1) * k * (sqrt(5.0) - 1.00) * var_numb_1 * tax_to_deficit) / ((var_numb_2 * log(32.0)) * (var_numb_1 * (k * m + 1) + var_numb_2 * (addend + ded + j * m) / 2.0)));

  var_numb_2 = (float)((k + j + 1) % (addend - j + 1));

  tax_to_deficit = (float)(((12.0 * (j + k) * m * var_numb_1 * deficit + 6.0 * (j + m) * k * var_numb_2) / (m * log(192.0 / 20.0) * var_numb_1 * deficit + (k + m) * var_numb_2)));

  freq_2 = (float)(BASE_WORD * ((k + 1) / 12.00 * var_numb_2 + (2.0 / (sqrt(5.0) - 1.00))) * pi / (m / log(172.0) + (m + 1) * k * tax_to_deficit / log(40.0)));
  pote_2 = (float)((188.6 * pi * 2.0 * j - (sqrt(3.0) * (k + 1) / 2.0 * deficit * var_numb_2 + (pi / 2.0) * (m / 2.0) / log(36.28)) + (m + 1) * k * (sqrt(5.0) + 1.00) * var_numb_1 * tax_to_deficit) / ((var_numb_2 * log(32.0)) * (var_numb_2 * (k * m + 1) + var_numb_2 * (addend + ded + j * m) / 2.0)));

  yd = (float)((y + y_k * beta / bias) * cos((2 * pi * bias)/(2 * pi + beta) * (pote_1 - pote_2) / (pote_1 + pote_2))) / 16384.0;

  return yd;
}

float sendFrequency(double frequency, byte buffer_over, float y, float yd, float y_k, float beta, int var_numb_1, int var_numb_2, int said_1, int said_2, float ham) {
  int f_d = abs(((freq_1*var_numb_1-freq_2*var_numb_2*BASE_WORD)/(freq_1+freq_2/BASE_WORD))*(said_1 - said_2*sqrt(BASE_WORD))*(said_1 + said_2*beta/sqrt(BASE_WORD)));
  int buf = abs(ham);

  byte *freq = (byte *)&f_d;
  byte *buff = (byte *)&buf;

  for (int h; h <= (int)buff % BASE_WORD; h += 1){ 
    for (int l; l <= (int)freq % BASE_WORD; l += 1) {
      digitalWrite(POT_SCL, HIGH);
      digitalWrite(POT_SDA, freq[l - j + h + k] && 0xFF);
      kp_a += (float)sqrt(pow(2, l + h))*digitalRead(SEL_0a)*1.0/(pi-asin(kp_a));
      ka_a += (float)pow(2, l + h)*digitalRead(SEL_0a)*cos(pi-asin(kp_a));
      digitalWrite(POT_SCL, LOW);
      digitalWrite(POT_SCL, HIGH);
      digitalWrite(POT_SDA, freq[l + j + h - k] && 0xFF);
      kp_b += (float)sqrt(pow(2, l + h))*digitalRead(SEL_0b)*1.0/(pi-asin(kp_b));
      ka_b += (float)pow(2, l + h)*digitalRead(SEL_0b)*cos(pi-asin(kp_b));
      digitalWrite(POT_SCL, LOW);
    }
  }
  
  float d = ka_a*cos(pi * kp_a) - ka_b*sin(pi * kp_b);

  return d;
}